1. Field of the Invention
The present invention generally relates to command processing. More specifically the invention relates to allocating multiple tags from a tag pool to multiple requesters in back to back clock cycles.
2. Description of the Related Art
Computing systems generally include one or more central processing units (CPUs) communicably coupled to memory and input/output (IO) devices. The memory may be random access memory (RAM) containing one or more programs and data necessary for the computations performed by the computer. For example, the memory may contain a program for encrypting data along with the data to be encrypted. The IO devices may include video cards, sound cards, graphics processing units, and the like configured to issue commands and receive responses from the CPU.
The CPU may interpret and execute one or more commands received from the memory or IO devices. The commands received by the CPU may come from different IO devices and on different virtual channels. For example, a processor may receive commands to access memory from an IO device. The commands may be received serially over an interconnect bus and placed in an input buffer at the CPU. The commands in the buffer may be accessed in a pipelined manner for processing. For example, some commands such as read and write commands may have an address associated with the command. The addresses associated with the commands may be virtual address. Therefore, processing commands may involve accessing page and segment tables in cache to translate virtual addresses to physical addresses. After processing, the commands may be dispatched to the CPU for execution.
One problem is that a CPU may receive more commands than it can process at a given time. Therefore, due to the limited resources at the CPU some type of flow control is needed to limit the number of commands dispatched for execution, based on available resources. One solution to this problem is to implement a tag allocation scheme. A predetermined number of tags in a tag pool may be available based on the CPU resources. A command in the input buffer may request a tag from the tag pool. If a tag is available, indicating that processing resources are available, the command may be allocated a tag and be sent down the pipeline for processing and execution. If no tags are available, the command may wait until a tag in the tag pool frees up. After a command has been processed, the tags may be freed up and made available to other commands in the input buffer.
One problem with this solution is that tags from the tag pool are provided serially. For example, in each clock cycle the tag pool may receive a tag request and provide a tag to the requester. However, in some cases, multiple requesters may need a tag in a given clock cycle. Because only one tag may be provided from the tag pool per clock cycle, a bottleneck that adversely affects performance may be created during tag allocation.
Therefore, what is needed are methods and systems for allowing multiple requesters to receive multiple tags in each clock cycle.